/*
 * @(#)CreateSymbols.java	1.7 07/03/21
 * 
 * Copyright (c) 2007 Sun Microsystems, Inc.  All Rights Reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *  
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.  Sun designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Sun in the LICENSE file that accompanied this code.
 *  
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *  
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *  
 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
 * CA 95054 USA or visit www.sun.com if you need additional information or
 * have any questions.
 */

package com.sun.tools.javac.sym;

import com.sun.tools.javac.api.JavacTaskImpl;
import com.sun.tools.javac.code.Kinds;
import com.sun.tools.javac.code.Scope;
import com.sun.tools.javac.code.Symbol.*;
import com.sun.tools.javac.code.Symbol;
import com.sun.tools.javac.code.Attribute;
import com.sun.tools.javac.code.Symtab;
import com.sun.tools.javac.code.Type;
import com.sun.tools.javac.jvm.ClassReader;
import com.sun.tools.javac.jvm.ClassWriter;
import com.sun.tools.javac.jvm.Pool;
import com.sun.tools.javac.processing.JavacProcessingEnvironment;
import com.sun.tools.javac.util.List;
import com.sun.tools.javac.util.Pair;
import com.sun.tools.javac.util.Name;

import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.EnumSet;
import java.util.Enumeration;
import java.util.HashSet;
import java.util.Properties;
import java.util.ResourceBundle;
import java.util.Set;

import javax.annotation.processing.AbstractProcessor;
import javax.annotation.processing.RoundEnvironment;
import javax.annotation.processing.SupportedAnnotationTypes;
import javax.annotation.processing.SupportedOptions;
import javax.lang.model.SourceVersion;
import javax.lang.model.element.ElementKind;
import javax.lang.model.element.TypeElement;
import javax.tools.Diagnostic;
import javax.tools.JavaCompiler;
import javax.tools.JavaFileManager.Location;
import javax.tools.JavaFileObject;
import static javax.tools.JavaFileObject.Kind.CLASS;
import javax.tools.StandardJavaFileManager;
import javax.tools.StandardLocation;
import javax.tools.ToolProvider;

/**
 * Used to generate a "symbol file" representing rt.jar that only
 * includes supported or legacy proprietary API.  Valid annotation
 * processor options:
 *
 * <dl>
 * <dt>com.sun.tools.javac.sym.Jar</dt>
 * <dd>Specifies the location of rt.jar.</dd>
 * <dt>com.sun.tools.javac.sym.Dest</dt>
 * <dd>Specifies the destination directory.</dd>
 * </dl>
 *
 * <p><b>This is NOT part of any API supported by Sun Microsystems.
 * If you write code that depends on this, you do so at your own
 * risk.  This code and its internal interfaces are subject to change
 * or deletion without notice.</b></p>
 *
 * @author Peter von der Ah\u00e9
 */
@SupportedOptions({"com.sun.tools.javac.sym.Jar","com.sun.tools.javac.sym.Dest"})
@SupportedAnnotationTypes("*")
public class CreateSymbols extends AbstractProcessor {
    private static my.Debug DEBUG=new my.Debug(my.Debug.CreateSymbols);//我加上的

    static Set<String> getLegacyPackages() {
        ResourceBundle legacyBundle
            = ResourceBundle.getBundle("com.sun.tools.javac.resources.legacy");
        Set<String> keys = new HashSet<String>();
        for (Enumeration<String> e = legacyBundle.getKeys(); e.hasMoreElements(); )
            keys.add(e.nextElement());
        return keys;
    }

    public boolean process(Set<? extends TypeElement> tes, RoundEnvironment renv) {
        try {//我加上的
        DEBUG.P(this,"process(2)");
        DEBUG.P("tes="+tes);
        DEBUG.P("renv.processingOver()="+renv.processingOver());
        try {
            if (renv.processingOver())
                createSymbols();
        } catch (IOException e) {
            processingEnv.getMessager()
                .printMessage(Diagnostic.Kind.ERROR, e.getLocalizedMessage());
        } catch (Throwable t) {
            Throwable cause = t.getCause();
            if (cause == null)
                cause = t;
            processingEnv.getMessager()
                .printMessage(Diagnostic.Kind.ERROR, cause.getLocalizedMessage());
        }
        return true;
        
        }finally{//我加上的
        DEBUG.P(0,this,"process(2)");
        }
    }

    void createSymbols() throws IOException {
        DEBUG.P(this,"createSymbols()");
        
        Set<String> legacy = getLegacyPackages();
        Set<String> legacyProprietary = getLegacyPackages();
        Set<String> documented = new HashSet<String>();
        Set<PackageSymbol> packages =
            ((JavacProcessingEnvironment)processingEnv).getSpecifiedPackages();
        String jarName = processingEnv.getOptions().get("com.sun.tools.javac.sym.Jar");
        
        DEBUG.P("legacy.size()="+legacy.size());
        DEBUG.P("packages="+packages);
        DEBUG.P("jarName="+jarName);
        
        if (jarName == null)
            throw new RuntimeException("Must use -Acom.sun.tools.javac.sym.Jar=LOCATION_OF_JAR");
        String destName = processingEnv.getOptions().get("com.sun.tools.javac.sym.Dest");
        
        DEBUG.P("destName="+destName);
        if (destName == null)
            throw new RuntimeException("Must use -Acom.sun.tools.javac.sym.Dest=LOCATION_OF_JAR");

        DEBUG.P("legacyProprietary.size()="+legacyProprietary.size());
        for (PackageSymbol psym : packages) {
            String name = psym.getQualifiedName().toString();
            legacyProprietary.remove(name);
            documented.add(name);
        }
        DEBUG.P("documented="+documented);
        DEBUG.P("legacyProprietary.size()="+legacyProprietary.size());

        JavaCompiler tool = ToolProvider.getSystemJavaCompiler();
        //DEBUG.P("tool="+tool);
        StandardJavaFileManager fm = tool.getStandardFileManager(null, null, null);
        Location jarLocation = StandardLocation.locationFor(jarName);
        File jarFile = new File(jarName);
        fm.setLocation(jarLocation, List.of(jarFile));
        fm.setLocation(StandardLocation.CLASS_PATH, List.<File>nil());
        fm.setLocation(StandardLocation.SOURCE_PATH, List.<File>nil());
        {
            ArrayList<File> bootClassPath = new ArrayList<File>();
            bootClassPath.add(jarFile);
            for (File path : fm.getLocation(StandardLocation.PLATFORM_CLASS_PATH)) {
                if (!new File(path.getName()).equals(new File("rt.jar")))
                    bootClassPath.add(path);
            }
            System.err.println("Using boot class path = " + bootClassPath);
            fm.setLocation(StandardLocation.PLATFORM_CLASS_PATH, bootClassPath);
        }
        // System.out.println(fm.getLocation(StandardLocation.PLATFORM_CLASS_PATH));
        File destDir = new File(destName);
        if (!destDir.exists())
            if (!destDir.mkdirs())
                throw new RuntimeException("Could not create " + destDir);
        fm.setLocation(StandardLocation.CLASS_OUTPUT, List.of(destDir));
        Set<String> hiddenPackages = new HashSet<String>();
        Set<String> crisp = new HashSet<String>();
        List<String> options = List.of("-XDdev");
        // options = options.prepend("-doe");
        // options = options.prepend("-verbose");
        JavacTaskImpl task = (JavacTaskImpl)
            tool.getTask(null, fm, null, options, null, null);
        com.sun.tools.javac.main.JavaCompiler compiler =
            com.sun.tools.javac.main.JavaCompiler.instance(task.getContext());
        ClassReader reader = ClassReader.instance(task.getContext());
        ClassWriter writer = ClassWriter.instance(task.getContext());
        Symtab syms = Symtab.instance(task.getContext());
        Attribute.Compound proprietary =
            new Attribute.Compound(syms.proprietaryType,
                                   List.<Pair<Symbol.MethodSymbol,Attribute>>nil());

        Type.moreInfo = true;
        Pool pool = new Pool();
        
        DEBUG.P("jarLocation="+jarLocation.getName());
        
        for (JavaFileObject file : fm.list(jarLocation, "", EnumSet.of(CLASS), true)) {
            String className = fm.inferBinaryName(jarLocation, file);
            
            DEBUG.P("className="+className);
            
            int index = className.lastIndexOf('.');
            String pckName = index == -1 ? "" : className.substring(0, index);
            boolean addLegacyAnnotation = false;
            
            DEBUG.P("pckName="+pckName);
            DEBUG.P("documented="+documented);
            
            if (documented.contains(pckName)) {
                if (!legacy.contains(pckName))
                    crisp.add(pckName);
                // System.out.println("Documented: " + className);
            } else if (legacyProprietary.contains(pckName)) {
                addLegacyAnnotation = true;
                // System.out.println("Legacy proprietary: " + className);
            } else {
                // System.out.println("Hidden " + className);
                hiddenPackages.add(pckName);
                continue;
            }
            TypeSymbol sym = (TypeSymbol)compiler.resolveIdent(className);
            DEBUG.P("sym.kind="+sym.kind);
            if (sym.kind != Kinds.TYP) {
                if (className.indexOf('$') < 0) {
                    System.err.println("Ignoring (other) " + className + " : " + sym);
                    System.err.println("   " + sym.getClass().getSimpleName() + " " + sym.type);
                }
                continue;
            }
            DEBUG.P("sym.complete()1");
            sym.complete();
            DEBUG.P("sym.complete()2");
            if (sym.getEnclosingElement().getKind() != ElementKind.PACKAGE) {
                System.err.println("Ignoring (bad) " + sym.getQualifiedName());
                continue;
            }
            ClassSymbol cs = (ClassSymbol) sym;
            
            DEBUG.P("addLegacyAnnotation="+addLegacyAnnotation);
            
            if (addLegacyAnnotation) {
                cs.attributes_field = (cs.attributes_field == null)
                    ? List.of(proprietary)
                    : cs.attributes_field.prepend(proprietary);
            }
            writeClass(pool, cs, writer);
        }

        //if (false) {
        if (true) {
            for (String pckName : crisp)
                System.out.println("Crisp: " + pckName);
            for (String pckName : hiddenPackages)
                System.out.println("Hidden: " + pckName);
            for (String pckName : legacyProprietary)
                System.out.println("Legacy proprietary: " + pckName);
            for (String pckName : documented)
                System.out.println("Documented: " + pckName);
        }
        
        DEBUG.P(0,this,"createSymbols()");
    }

    void writeClass(final Pool pool, final ClassSymbol cs, final ClassWriter writer)
        throws IOException
    {
        DEBUG.P(this,"writeClass(3)");
        DEBUG.P("cs="+cs);
        
        try {
            pool.reset();
            cs.pool = pool;
            writer.writeClass(cs);
            for (Scope.Entry e = cs.members().elems; e != null; e = e.sibling) {
                if (e.sym.kind == Kinds.TYP) {
                    ClassSymbol nestedClass = (ClassSymbol)e.sym;
                    nestedClass.complete();
                    writeClass(pool, nestedClass, writer);
                }
            }
        } catch (ClassWriter.StringOverflow ex) {
            throw new RuntimeException(ex);
        } catch (ClassWriter.PoolOverflow ex) {
            throw new RuntimeException(ex);
        }
        
        DEBUG.P(0,this,"writeClass(3)");
    }

    public SourceVersion getSupportedSourceVersion() {
        return SourceVersion.latest();
    }

    // used for debugging
    public static void main(String... args) throws Exception{
        
        String rt_jar = args[0];
        String dest = args[1];
        args = new String[] {
            "-Xbootclasspath:" + rt_jar,
            "-XDprocess.packages",
            "-proc:only",
            "-processor",
            "com.sun.tools.javac.sym.CreateSymbols",
            "-Acom.sun.tools.javac.sym.Jar=" + rt_jar,
            "-Acom.sun.tools.javac.sym.Dest=" + dest,
            // <editor-fold defaultstate="collapsed">
            "java.applet",
            "java.awt",
            "java.awt.color",
            "java.awt.datatransfer",
            "java.awt.dnd",
            "java.awt.event",
            "java.awt.font",
            "java.awt.geom",
            "java.awt.im",
            "java.awt.im.spi",
            "java.awt.image",
            "java.awt.image.renderable",
            "java.awt.print",
            "java.beans",
            "java.beans.beancontext",
            "java.io",
            "java.lang",
            "java.lang.annotation",
            "java.lang.instrument",
            "java.lang.management",
            "java.lang.ref",
            "java.lang.reflect",
            "java.math",
            "java.net",
            "java.nio",
            "java.nio.channels",
            "java.nio.channels.spi",
            "java.nio.charset",
            "java.nio.charset.spi",
            "java.rmi",
            "java.rmi.activation",
            "java.rmi.dgc",
            "java.rmi.registry",
            "java.rmi.server",
            "java.security",
            "java.security.acl",
            "java.security.cert",
            "java.security.interfaces",
            "java.security.spec",
            "java.sql",
            "java.text",
            "java.text.spi",
            "java.util",
            "java.util.concurrent",
            "java.util.concurrent.atomic",
            "java.util.concurrent.locks",
            "java.util.jar",
            "java.util.logging",
            "java.util.prefs",
            "java.util.regex",
            "java.util.spi",
            "java.util.zip",
            "javax.accessibility",
            "javax.activation",
            "javax.activity",
            "javax.annotation",
            "javax.annotation.processing",
            "javax.crypto", //在jce.jar
            "javax.crypto.interfaces",//在jce.jar
            "javax.crypto.spec",//在jce.jar
            "javax.imageio",
            "javax.imageio.event",
            "javax.imageio.metadata",
            "javax.imageio.plugins.jpeg",
            "javax.imageio.plugins.bmp",
            "javax.imageio.spi",
            "javax.imageio.stream",
            "javax.jws",
            "javax.jws.soap",
            "javax.lang.model",
            "javax.lang.model.element",
            "javax.lang.model.type",
            "javax.lang.model.util",
            "javax.management",
            "javax.management.loading",
            "javax.management.monitor",
            "javax.management.relation",
            "javax.management.openmbean",
            "javax.management.timer",
            "javax.management.modelmbean",
            "javax.management.remote",
            "javax.management.remote.rmi",
            "javax.naming",
            "javax.naming.directory",
            "javax.naming.event",
            "javax.naming.ldap",
            "javax.naming.spi",
            "javax.net",//在jsse.jar
            "javax.net.ssl",//在jsse.jar
            "javax.print",
            "javax.print.attribute",
            "javax.print.attribute.standard",
            "javax.print.event",
            "javax.rmi",
            "javax.rmi.CORBA",
            "javax.rmi.ssl",
            "javax.script",
            "javax.security.auth",
            "javax.security.auth.callback",
            "javax.security.auth.kerberos",
            "javax.security.auth.login",
            "javax.security.auth.spi",
            "javax.security.auth.x500",
            "javax.security.cert",//在jsse.jar
            "javax.security.sasl",
            "javax.sound.sampled",
            "javax.sound.sampled.spi",
            "javax.sound.midi",
            "javax.sound.midi.spi",
            "javax.sql",
            "javax.sql.rowset",
            "javax.sql.rowset.serial",
            "javax.sql.rowset.spi",
            "javax.swing",
            "javax.swing.border",
            "javax.swing.colorchooser",
            "javax.swing.filechooser",
            "javax.swing.event",
            "javax.swing.table",
            "javax.swing.text",
            "javax.swing.text.html",
            "javax.swing.text.html.parser",
            "javax.swing.text.rtf",
            "javax.swing.tree",
            "javax.swing.undo",
            "javax.swing.plaf",
            "javax.swing.plaf.basic",
            "javax.swing.plaf.metal",
            "javax.swing.plaf.multi",
            "javax.swing.plaf.synth",
            "javax.tools",
            "javax.transaction",
            "javax.transaction.xa",
            "javax.xml.parsers",
            "javax.xml.bind",
            "javax.xml.bind.annotation",
            "javax.xml.bind.annotation.adapters",
            "javax.xml.bind.attachment",
            "javax.xml.bind.helpers",
            "javax.xml.bind.util",
            "javax.xml.soap",
            "javax.xml.ws",
            "javax.xml.ws.handler",
            "javax.xml.ws.handler.soap",
            "javax.xml.ws.http",
            "javax.xml.ws.soap",
            "javax.xml.ws.spi",
            "javax.xml.transform",
            "javax.xml.transform.sax",
            "javax.xml.transform.dom",
            "javax.xml.transform.stax",
            "javax.xml.transform.stream",
            "javax.xml",
            "javax.xml.crypto",
            "javax.xml.crypto.dom",
            "javax.xml.crypto.dsig",
            "javax.xml.crypto.dsig.dom",
            "javax.xml.crypto.dsig.keyinfo",
            "javax.xml.crypto.dsig.spec",
            "javax.xml.datatype",
            "javax.xml.validation",
            "javax.xml.namespace",
            "javax.xml.xpath",
            "javax.xml.stream",
            "javax.xml.stream.events",
            "javax.xml.stream.util",
            "org.ietf.jgss",
            "org.omg.CORBA",
            "org.omg.CORBA.DynAnyPackage",
            "org.omg.CORBA.ORBPackage",
            "org.omg.CORBA.TypeCodePackage",
            "org.omg.stub.java.rmi",
            "org.omg.CORBA.portable",
            "org.omg.CORBA_2_3",
            "org.omg.CORBA_2_3.portable",
            "org.omg.CosNaming",
            "org.omg.CosNaming.NamingContextExtPackage",
            "org.omg.CosNaming.NamingContextPackage",
            "org.omg.SendingContext",
            "org.omg.PortableServer",
            "org.omg.PortableServer.CurrentPackage",
            "org.omg.PortableServer.POAPackage",
            "org.omg.PortableServer.POAManagerPackage",
            "org.omg.PortableServer.ServantLocatorPackage",
            "org.omg.PortableServer.portable",
            "org.omg.PortableInterceptor",
            "org.omg.PortableInterceptor.ORBInitInfoPackage",
            "org.omg.Messaging",
            "org.omg.IOP",
            "org.omg.IOP.CodecFactoryPackage",
            "org.omg.IOP.CodecPackage",
            "org.omg.Dynamic",
            "org.omg.DynamicAny",
            "org.omg.DynamicAny.DynAnyPackage",
            "org.omg.DynamicAny.DynAnyFactoryPackage",
            "org.w3c.dom",
            "org.w3c.dom.events",
            "org.w3c.dom.bootstrap",
            "org.w3c.dom.ls",
            "org.xml.sax",
            "org.xml.sax.ext",
            "org.xml.sax.helpers",
            "com.sun.java.browser.dom",
            "org.w3c.dom",
            "org.w3c.dom.bootstrap",
            "org.w3c.dom.ls",
            "org.w3c.dom.ranges",
            "org.w3c.dom.traversal",
            "org.w3c.dom.html",
            "org.w3c.dom.stylesheets",
            "org.w3c.dom.css",
            "org.w3c.dom.events",
            "org.w3c.dom.views",
            "com.sun.management",
            "com.sun.security.auth",
            "com.sun.security.auth.callback",
            "com.sun.security.auth.login",
            "com.sun.security.auth.module",
            "com.sun.security.jgss",
            "com.sun.net.httpserver",
            "com.sun.net.httpserver.spi",
            "javax.smartcardio"
            // </editor-fold>
        };
        com.sun.tools.javac.Main.compile(args);
        
        /*
        String[] defaultToolsLocation
            = new String[]{ "lib", "tools.jar" };
        java.io.File file = new java.io.File(System.getProperty("java.home"));
        System.out.println(file);
        System.out.println(file.getName());
        System.out.println(file.getParentFile().getName());
        System.out.println(file.getParentFile());
        
        
            if (file.getName().equalsIgnoreCase("jre"))
                file = file.getParentFile();
            for (String name : defaultToolsLocation)
                file = new File(file, name);
            java.net.URL[] urls = {file.toURI().toURL()};
            
           System.out.println( urls[0].toString());
           System.out.println("urls.length="+urls.length);
           System.out.println("System.getProperty(\"sun.tools.ToolProvider\")="+System.getProperty("sun.tools.ToolProvider"));
           System.setProperty("sun.tools.ToolProvider","sun.tools.ToolProvider");
           System.out.println("System.getProperty(\"sun.tools.ToolProvider\")="+System.getProperty("sun.tools.ToolProvider"));
        
        String rt_jar = args[0];
        String dest = args[1];
        args = new String[] {
            "-Xbootclasspath:" + rt_jar,
            "-XDprocess.packages",
            "-proc:only",
            "-processor",
            "com.sun.tools.javac.sym.CreateSymbols",
            "-Acom.sun.tools.javac.sym.Jar=" + rt_jar,
            "-Acom.sun.tools.javac.sym.Dest=" + dest,
            "my",
            "my.test",
            "my.test.TestExist",
            "my.test.TestNotFound"
        };
        com.sun.tools.javac.Main.compile(args);*/
    }

}
